/*
 * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 * This file is part of the lwIP TCP/IP stack.
 *
 * Author: Adam Dunkels <adam@sics.se>
 * Author: Stefano Oliveri <software@stf12.net>
 *
 * This file was modified by Stefano Oliveri to implement the system emulation layer for STR91x.
 *
 */

/* lwIP includes. */
#include "debug.h"
#include "def.h"
#include "sys.h"
#include "mem.h"
#include "stats.h"
#include "sys_arch.h"
#include <stdio.h>
//#include "printf.h"
#include <string.h>
#include "os_cpu.h"
#include "cc.h"


//static  struct          timeoutlist s_timeoutlist[SYS_THREAD_MAX];
static  u8_t            s_nextthread = 0;
static  OS_Q_DATA       mbox_query_dat;
static  sys_thread_opt  *theard_opt_ptr;
//static  OS_STK          *threadtaskstk[SYS_THREAD_MAX];
static  OS_STK          threadtaskstk[TCPIP_THREAD_STACKSIZE];
/*****
*
*/
#if 0
u16_t mstoOSTicks(u32_t ms)
{

    if(ms==0)   return 0;
    else{


    }
}
#endif
/*-----------------------------------------------------------------------------------*/
//  Creates an empty mailbox.
err_t sys_mbox_new(sys_mbox_t *mbox,int size)
{

#ifndef mboxstr
    void *mboxarray;
    #if OS_CRITICAL_METHOD == 3                                /* Allocate storage for CPU status register */
        OS_CPU_SR  cpu_sr;
    #endif
    OS_ENTER_CRITICAL();
    mboxarray=malloc(size*sizeof(int));
    OS_EXIT_CRITICAL();
    *mbox=OSQCreate(&mboxarray,size);

#else
	mbox->mbox = OSQCreate((mbox->mbox_context), size);
#endif
    if(mbox!=SYS_MBOX_NULL){

#if SYS_STATS
      ++lwip_stats.sys.mbox.used;
      if (lwip_stats.sys.mbox.max < lwip_stats.sys.mbox.used) {
         lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used;
	  }
#endif /* SYS_STATS */
        return ERR_OK;
    }else{
        return ERR_RTE;
    }
}

/*-----------------------------------------------------------------------------------*/
/*
  Deallocates a mailbox. If there are messages still present in the
  mailbox when the mailbox is deallocated, it is an indication of a
  programming error in lwIP and the developer should be notified.
*/
void sys_mbox_free(sys_mbox_t *mbox)
{
    u8_t    err;
    u8_t    i,j,cnt=0;
    u16_t   nmsgs;

#ifndef mboxstr
    //query queue's status
    OSQQuery(*mbox, &mbox_query_dat);
#else
    OSQQuery(mbox->mbox, &mbox_query_dat);
#endif

    if((void *)mbox_query_dat.OSMsg!=SYS_MBOX_NULL){
        //here if program execture ,then there are sevral msg in mailbox
        //printf how mangy total number dose mailbox have
        printf("There is %u msg\n\r",mbox_query_dat.OSNMsgs);

        //printf msg context
        for(nmsgs=0;nmsgs<mbox_query_dat.OSNMsgs;nmsgs++){
            //
        }

        //printf which task will wait these msg
        for(i=0;i<8;i++){

            if(mbox_query_dat.OSEventGrp&(1<<i)){
                for(j=0;j<8;j++){

                    if(mbox_query_dat.OSEventTbl[i]&(1<<j)){
                        cnt=i<<3+j;
                        printf("the os_event task pri remained is [%u]\r\n",cnt);
                    }
                }
            }
        }

#if SYS_STATS
	    lwip_stats.sys.mbox.err++;
#endif /* SYS_STATS */
	}

#ifndef mboxstr
    //delete queue
    OSQDel(*mbox, OS_DEL_ALWAYS, &err);
#else
    OSQDel(mbox->mbox, OS_DEL_ALWAYS, &err);
#endif
#if SYS_STATS
     --lwip_stats.sys.mbox.used;
#endif /* SYS_STATS */
}

/*-----------------------------------------------------------------------------
//Posts the "msg" to the mailbox.
Posts the "msg" to the mailbox. This function have to block
until  the "msg" is really posted.
------------------------------------------------------------------------------*/
void sys_mbox_post(sys_mbox_t *mbox, void *data)
{
    u8_t err;

	do{
#ifndef mboxstr
	    err=OSQPost(*mbox, data);
#else
        err=OSQPost(mbox->mbox, data);
#endif

	}while(err==OS_NO_ERR);

}


/*----------------------------------------------------------------------------
//   Try to post the "msg" to the mailbox.
Try to post the "msg" to the mailbox. Returns ERR_MEM if this one  is full,
else, ERR_OK if the "msg" is posted.
-----------------------------------------------------------------------------*/
err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
{
    u8_t    err;

#ifndef mboxstr
    //post msg;
    err=OSQPost(*mbox, msg);
#else
    err=OSQPost(mbox->mbox, msg);
#endif
    //check msg
    if(err==OS_NO_ERR){

        return  ERR_OK;

    }else if((err==OS_Q_FULL)||(err==OS_ERR_EVENT_TYPE)){


#if SYS_STATS
      lwip_stats.sys.mbox.err++;
#endif /* SYS_STATS */

    return  ERR_MEM;
    }
	return 	ERR_OK;
}

/*----------------------------------------------------------------------------*/
/*
  Blocks the thread until a message arrives in the mailbox, but does
  not block the thread longer than "timeout" milliseconds (similar to
  the sys_arch_sem_wait() function). The "msg" argument is a result
  parameter that is set by the function (i.e., by doing "*msg =
  ptr"). The "msg" parameter maybe NULL to indicate that the message
  should be dropped.

  The return values are the same as for the sys_arch_sem_wait() function:
  Number of milliseconds spent waiting or SYS_ARCH_TIMEOUT if there was a
  timeout.

  Note that a function with a similar name, sys_mbox_fetch(), is
  implemented by lwIP.
*/
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
{
    u8_t err;

    u32_t sys_arch_mbox_fetch_ticks;

    u32_t StartTime, EndTime, Elapsed;


	StartTime = OSTimeGet();
    //change timeout to ticks
    if(timeout==0) sys_arch_mbox_fetch_ticks=0;
    else{
        sys_arch_mbox_fetch_ticks=(timeout*OS_TICKS_PER_SEC)/1000;
        if(sys_arch_mbox_fetch_ticks<1) sys_arch_mbox_fetch_ticks=1;
    }

#ifndef mboxstr
    *msg = OSQPend(*mbox, sys_arch_mbox_fetch_ticks, &err);
#else
    *msg = OSQPend(mbox->mbox, sys_arch_mbox_fetch_ticks, &err);
#endif
    if(err==OS_NO_ERR){
	    EndTime = OSTimeGet();

		Elapsed = ((EndTime - StartTime)/OS_TICKS_PER_SEC)*1000;

		return ( Elapsed );
	}else if(err==OS_TIMEOUT)   return SYS_ARCH_TIMEOUT;
    return SYS_ARCH_TIMEOUT;

}

/*-----------------------------------------------------------------------------------*/
/*
  Similar to sys_arch_mbox_fetch, but if message is not ready immediately, we'll
  return with SYS_MBOX_EMPTY.  On success, 0 is returned.
*/
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
{
	void *dummyptr;

	if ( msg == NULL )
	{
		msg = &dummyptr;
	}

#ifndef mboxstr
   *msg = OSQAccept(*mbox);
#else
   *msg= OSQAccept(mbox->mbox);
#endif
   if(msg==SYS_MBOX_NULL)
   {
      return SYS_MBOX_EMPTY;
   }
   else
   {
          return ERR_OK;
   }
}


/*---------------------------------------------------------------------------*/
/****
Returns 1 if the mailbox is valid, 0 if it is not valid.
When using pointers, a simple way is to check the pointer for != NULL.
When directly using OS structures, implementing this may be more complex.
This may also be a define, in which case the function is not prototyped.
***/
int sys_mbox_valid(sys_mbox_t *mbox)
{
    #ifndef mboxstr
    if((void *)mbox!=SYS_MBOX_NULL)   return 1;
    else    return 0;
    #else
    if(((void *)mbox!=SYS_MBOX_NULL)&&((void *)mbox->mbox!=SYS_MBOX_NULL))   return 1;
    else    return 0;
    #endif

}
/*----------------------------------------------------------------------------*/
/****
Invalidate a mailbox so that sys_mbox_valid() returns 0.
ATTENTION: This does NOT mean that the mailbox shall be deallocated:
sys_mbox_free() is always called before calling this function!
This may also be a define, in which case the function is not prototyped.
*****/
void sys_mbox_set_invalid(sys_mbox_t *mbox)
{
#ifndef mboxstr
    if(mbox != (void *)0)   *mbox = (void *)0;

#else
    if(mbox->mbox!=SYS_MBOX_NULL)   mbox->mbox=SYS_MBOX_NULL;

#endif

}
/*-----------------------------------------------------------------------------------*/
//  Creates and returns a new semaphore. The "count" argument specifies
//  the initial state of the semaphore.
err_t sys_sem_new(sys_sem_t *sem,u8_t count)
{

    *sem=OSSemCreate(count);

	if(*sem!= SYS_SEM_NULL)
	{
      return ERR_OK;

	}else{

#if SYS_STATS
      ++lwip_stats.sys.sem.err;
#endif /* SYS_STATS */

		return ERR_VAL;	// TODO need assert

	}
}

/*-----------------------------------------------------------------------------*/
/*
  Blocks the thread while waiting for the semaphore to be
  signaled. If the "timeout" argument is non-zero, the thread should
  only be blocked for the specified time (measured in
  milliseconds).

  If the timeout argument is non-zero, the return value is the number of
  milliseconds spent waiting for the semaphore to be signaled. If the
  semaphore wasn't signaled within the specified time, the return value is
  SYS_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
  (i.e., it was already signaled), the function may return zero.

  Notice that lwIP implements a function with a similar name,
  sys_sem_wait(), that uses the sys_arch_sem_wait() function.
*/
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
{
    u32_t StartTime, EndTime, Elapsed;
    u8_t  err;
    u32_t   sem_arch_timeout;

	StartTime = OSTimeGet();

    if(timeout==0)  sem_arch_timeout=0;
    else{
        sem_arch_timeout=(timeout*OS_TICKS_PER_SEC)/1000;
        if(sem_arch_timeout<1) sem_arch_timeout=1;
    }

    OSSemPend(*sem, sem_arch_timeout, &err);
    //is error?
     if(err==OS_NO_ERR){
          //get end time
			EndTime = OSTimeGet();
            //return time;
			Elapsed = ((EndTime - StartTime)/OS_TICKS_PER_SEC)*1000;

			return (Elapsed); // return time blocked TODO test
     }
     return SYS_ARCH_TIMEOUT;
}

/*------------------------------------------------------------------------------*/
// Signals a semaphore
void sys_sem_signal(sys_sem_t *sem)
{
    OSSemPost( *sem );
}

/*------------------------------------------------------------------------------*/
// Deallocates a semaphore
void sys_sem_free(sys_sem_t *sem)
{
	u8_t err;
#if SYS_STATS
      --lwip_stats.sys.sem.used;
#endif /* SYS_STATS */

	OSSemDel(*sem,OS_DEL_ALWAYS,&err);

}

int sys_sem_valid(sys_sem_t *sem)
{

    if(*sem!=SYS_SEM_NULL)   return 1;
    else    return 0;

}
/** Set a semaphore invalid so that sys_sem_valid returns 0 */
void sys_sem_set_invalid(sys_sem_t *sem)
{
    if(*sem != SYS_SEM_NULL) {
        *sem = SYS_SEM_NULL;
        }
}


/*-----------------------------------------------------------------------------------*/
// Initialize sys arch
void sys_init(void)
{
	// keep track of how many threads have been created
	s_nextthread = 0;

    //initalize system
    theard_opt_ptr=(sys_thread_opt *)malloc(sizeof(sys_thread_opt));
    theard_opt_ptr->threadname=0;
    theard_opt_ptr->threadid=0;
    theard_opt_ptr->threadtotalnum=0;
    theard_opt_ptr->next=NULL;

}

/*-----------------------------------------------------------------------------------*/
/*
  Starts a new thread with priority "prio" that will begin its execution in the
  function "thread()". The "arg" argument will be passed as an argument to the
  thread() function. The id of the new thread is returned. Both the id and
  the priority are system dependent.
*/
sys_thread_t sys_thread_new(const char *name, void (* thread)(void *arg), void *arg, int stacksize, unsigned char prio)
{
    u8_t    err;
    sys_thread_opt *p1,*p2;
    //sys_thread_opt *p2;

   if ( s_nextthread < SYS_THREAD_MAX ){

      //result = xTaskCreate( thread, ( signed portCHAR * ) name, stacksize, arg, prio, &CreatedTask );
       //threadtaskstk[s_nextthread++] = (OS_STK *)malloc(stacksize);
       //threadtaskstk= (OS_STK *)malloc(stacksize);
      //create task
       err=OSTaskCreate(thread, arg, &threadtaskstk[stacksize-1], prio);
       if(err==OS_NO_ERR){
	    // For each task created, store te task handle (pid) in the timers array.
	    // This scheme doesn't allow for threads to be deleted
		#if 1
            p1=theard_opt_ptr;
            while(p1->next!=NULL){
                p1=p1->next;
            }
            p2=(sys_thread_opt *)malloc(sizeof(sys_thread_opt));
            p2->threadname=(u8_t *)name;
            p2->threadid=prio;
            p2->threadtotalnum=s_nextthread+1;
            p2->next=NULL;
            p1->next=p2;
	    #endif
            //s_nextthread++;
            return prio;
       }else{

        return 0xff;
       }
   }else{
      printf("create tcpip thread error...\r\n");
      return 0xff;
   }
}

/*
  This optional function does a "fast" critical region protection and returns
  the previous protection level. This function is only called during very short
  critical regions. An embedded system which supports ISR-based drivers might
  want to implement this function by disabling interrupts. Task-based systems
  might want to implement this by using a mutex or disabling tasking. This
  function should support recursive calls from the same task or interrupt. In
  other words, sys_arch_protect() could be called while already protected. In
  that case the return value indicates that it is already protected.

  sys_arch_protect() is only required if your port is supporting an operating
  system.
*/
sys_prot_t sys_arch_protect(void)
{
	return OS_CPU_SR_Save();

}

/*
  This optional function does a "fast" set of critical region protection to the
  value specified by pval. See the documentation for sys_arch_protect() for
  more information. This function is only required if your port is supporting
  an operating system.
*/
void sys_arch_unprotect(sys_prot_t pval)
{
	OS_CPU_SR_Restore(pval);
}



u32_t sys_now(void)
{
    return (OSTimeGet()*1000)/OS_TICKS_PER_SEC;
}

#if 0
void  sys_arch_msleep(u32_t ms)
{
#if OS_TIME_DLY_HMSM_EN>0
    OSTimeDlyHMSM(ms/3600000, (ms/60000)%60, (ms/1000)%60, ms%1000);
#else
    u32_t msTicks;
    if(ms==0) OSTimeDly(ms);
    else{
        msTicks=(ms*OS_TICKS_PER_SEC)/1000;
        if(msTicks<1) msTicks=1;
        else if(msTicks>0xffff) msTicks=0xffff;
        OSTimeDly(msTicks);
    }
#endif

}
#endif
